const mongoose = require("mongoose");
const { ArticleDetailSchema } = require("../DBModel/Article");
const {
  getAuthorInfoById,
  addArticleToAuthor,
  addLikeToAuthor,
  deleteLikeFromAuthor,
  deleteArticleFromAuthor,
} = require("./AuthorApi");
// 这里发生了一件比较有意思的事情就是，在这里引入的getArticleDetail方法
// 又从这个文件中导出去了
const { getArticleDetail, isAuthorExist } = require("./DBcommentApi");

// 获取分页文章列表，主要是用在首页展示文章列表
const getPaginatedArticles = async (pageNumber, pageSize) => {
  try {
    // 使用模型
    const Article = mongoose.model("Article", ArticleDetailSchema);

    // 计算跳过的记录数
    const skipCount = (pageNumber - 1) * pageSize;

    // 查询数据，按 _id 字段降序排序
    const res = await Article.find()
      .sort({ _id: -1 }) // 按 _id 降序排序
      .skip(skipCount)
      .limit(pageSize);

    // 返回结果
    return res;
  } catch (error) {
    console.error("Error fetching articles:", error);
    throw error;
  }
};

// 增加文章，成功返回文章对象，失败返回 null
const addArticle = async (authorId, articleInfo) => {
  try {
    // 使用模型
    const Article = mongoose.model("Article", ArticleDetailSchema);

    // 查找作者
    const author = await getAuthorInfoById(authorId);

    // 未查询到作者时返回 null
    if (!author) {
      console.log(`未查询到作者 id ${authorId}`);
      return null;
    }

    // 创建文章对象
    const article = new Article({
      title: articleInfo.title,
      summary: articleInfo.summary || "",
      authorNickName: author.nickname || author.email,
      authorEmail: author.email,
      content: articleInfo.content,
      likes: 0,
      views: 0,
      // collects: 0,
      createTime: articleInfo.createTime || new Date(),
      commentList: [],
    });

    // 保存文章
    const res = await article.save();

    // 保存文章失败
    if (!res) {
      console.log("保存文章失败");
      return null;
    }

    // 保存文章之后，更新作者的文章列表
    const res2 = await addArticleToAuthor(authorId, res._id);

    // 更新作者的文章列表失败
    if (!res2) {
      console.log("更新作者的文章列表失败");
      return null;
    }

    // 返回文章
    return res;
  } catch (error) {
    console.error("Error adding article:", error);
    return null;
  }
};

// 删除文章，删除成功返回文章对象，失败返回 null
const deleteArticleById = async (articleId, authorId) => {
  try {
    // 使用模型
    const Article = mongoose.model("Article", ArticleDetailSchema);

    // 查询作者
    const author = await getAuthorInfoById(authorId);

    // 查询不到作者
    if (!author) {
      console.log(`未查询到作者 id ${authorId}`);
      return null;
    }

    // 查询并且删除文章，返回删除的文章，失败返回 null
    const res = await Article.findByIdAndDelete(articleId);

    // 查询文章失败
    if (!res) {
      console.log(`查询文章失败，articleId ${articleId}`);
      return null;
    }

    // 删除文章之后，更新作者的文章列表
    const res2 = await deleteArticleFromAuthor(authorId, articleId);

    // 删除文章失败
    if (!res2) {
      console.log(`删除文章失败，articleId ${articleId}`);
      return null;
    }

    // 返回删除的文章
    return res;
  } catch (error) {
    console.error("Error deleting article:", error);
    return null;
  }
};

// 修改文章，标题，摘要，内容，查询成功返回修改后的文章，失败返回 null
const modifyArticle = async (articleId, authorId, articleInfo) => {
  try {
    // 使用模型
    const Article = mongoose.model("Article", ArticleDetailSchema);

    // 查询作者
    const author = await getAuthorInfoById(authorId);

    // 查询文章是否存在
    const article = await Article.findById(articleId);

    // 未查询到文章
    if (!article) {
      console.log(`未查询到文章 id ${articleId}`);
      return null;
    }

    // 查询不到作者
    if (!author) {
      console.log(`未查询到作者 id ${authorId}`);
      return null;
    }

    // 作者是否拥有该文章
    if (!author.articles.includes(articleId)) {
      console.log(`作者 id ${authorId} 不拥有文章 id ${articleId}`);
      return null;
    }

    // 修改文章
    const res = await Article.findByIdAndUpdate(
      articleId,
      {
        title: articleInfo.title || article.title,
        summary: articleInfo.summary || article.summary,
        content: articleInfo.content || article.content,
      },
      // 表示返回更新后的文档
      { new: true }
    );

    // 修改失败时
    if (!res) {
      console.log(`修改文章失败，articleId ${articleId}`);
      return null;
    }

    // 返回修改后的文章
    return res;
  } catch (error) {
    console.error("Error modifying article:", error);
    return null;
  }
};

// 添加文章的评论，成功返回更新后的文章，失败返回 null
// 只有查找失败时才会返回 null，其他情况不管是更新成功还是失败都会返回更新后的文章
const addComment = async (articleId, authorId, commentInfo) => {
  try {
    // 使用模型
    const Article = mongoose.model("Article", ArticleDetailSchema);

    // 查询文章
    const article = await Article.findById(articleId);

    // 未查询到文章
    if (!article) {
      console.log(`未查询到文章 id ${articleId}`);
      return null;
    }

    // 查找作者
    const author = await getAuthorInfoById(authorId);

    // 未查询到作者
    if (!author) {
      console.log(`未查询到作者 id ${authorId}`);
      return null;
    }

    // 更新文章的评论列表
    const res = await Article.findByIdAndUpdate(
      articleId,
      {
        $push: {
          commentList: {
            authorNickName: author.nickname,
            authorAvatar: author.avatar,
            content: commentInfo.content,
            authorEmail: author.email,
            createTime: commentInfo.createTime || new Date(),
            replyList: [],
            _id: new mongoose.Types.ObjectId(),
          },
        },
      },
      // 表示返回更新后的文档，这会返回更新之后的文章
      { new: true }
    );

    // 更新失败时
    if (!res) {
      console.log(`添加评论失败，articleId ${articleId}`);
      return null;
    }

    // 返回更新后的文章
    return res;
  } catch (error) {
    console.error("Error adding comment:", error);
    return null;
  }
};

// 增加文章评论的回复
// 只有查找失败时才会返回 null，其他情况不管是更新成功还是失败都会返回更新后的文章
const addArticleCommentReply = async (
  articleId,
  commentId,
  authorId,
  replyInfo
) => {
  try {
    // 使用模型
    const Article = mongoose.model("Article", ArticleDetailSchema);

    // 查询文章
    const article = await getArticleDetail(articleId);

    // 未查询到文章
    if (!article) {
      console.log(`未查询到文章 id ${articleId}`);
      return null;
    }

    // 查找评论
    const commentIndex = article.commentList.some(
      (comment) => comment._id.toString() === commentId
    );

    // 未找到评论
    if (commentIndex === -1) {
      console.log(`未找到文章Id${articleId} 的评论 id ${commentId}`);
      return null;
    }

    // 查找作者
    const author = await getAuthorInfoById(authorId);

    // 未查询到作者
    if (!author) {
      console.log(`未查询到作者 id ${authorId}`);
      return null;
    }

    // 使用 updateOne 方法更新文章中的特定评论
    // const updatedArticle = await Article.updateOne(
    //   { _id: articleId, "commentList._id": commentId }, // 查询条件
    //   {
    //     $push: {
    //       "commentList.$.replyList": {
    //         _id: new mongoose.Types.ObjectId(),
    //         authorNickName: author.nickname,
    //         authorAvatar: author.avatar,
    //         authorEmail: author.email,
    //         createTime: replyInfo.createTime || new Date(),
    //         content: replyInfo.content,
    //       },
    //     },
    //   }, // 更新操作
    //   // 表示返回更新后的文档
    //   // runValidators: true, // 运行验证器，看看是否符合评论的schema
    //   { new: true, runValidators: true }
    // );

    // 使用 findByIdAndUpdate 方法更新文章中的特定评论
    const updatedArticle = await Article.findByIdAndUpdate(
      articleId, // 文章ID
      {
        $push: {
          "commentList.$[comment].replyList": {
            _id: new mongoose.Types.ObjectId(),
            authorNickName: author.nickname || author.email,
            authorAvatar: author.avatar,
            authorEmail: author.email,
            createTime: replyInfo.createTime || new Date(),
            content: replyInfo.content,
          },
        },
      },
      {
        new: true, // 返回更新后的文档
        runValidators: true, // 运行验证器
        arrayFilters: [{ "comment._id": commentId }], // 过滤条件
      }
    );

    // 更新失败时
    if (!updatedArticle) {
      console.log(`未找到文章Id ${articleId} 评论Id ${commentId}`);
      return null;
    }

    // // 找到文章，但是评论更新失败时
    // if (!updatedArticle.modifiedCount) {
    //   console.log(
    //     `评论更新失败，articleId ${articleId} commentId ${commentId}`
    //   );
    //   return null;
    // }

    return updatedArticle;
  } catch (error) {
    console.log("Error adding comment reply:", error);
    return null;
  }
};

// 删除文章评论，成功返回更新后的文章，失败返回 null
// const deleteArticleComment = async (articleId, commentId, authorEmail) => {
//   try {
//     // 使用模型
//     const Article = mongoose.model("Article", ArticleDetailSchema);

//     //
//     const updatedArticle = await Article.updateOne(
//       { _id: articleId }, // 查询条件
//       { $pull: { commentList: { _id: commentId } } }, // 更新操作
//       {
//         new: true, // 返回更新后的文档
//         runValidators: true, // 运行验证器
//       }
//     );

//     // 返回更新之后的文章
//     return updatedArticle;
//   } catch (error) {
//     console.log("Error deleting comment:", error);
//     return null;
//   }
// };
const deleteArticleComment = async (articleId, commentId, authorEmail) => {
  try {
    // 使用模型
    const Article = mongoose.model("Article", ArticleDetailSchema);

    // 查找文章
    const article = await Article.findById(articleId);

    if (!article) {
      console.log(`未找到文章Id ${articleId}`);
      return null;
    }

    // 查找评论
    const commentIndex = article.commentList.findIndex(
      (comment) => comment._id.toString() === commentId
    );

    if (commentIndex === -1) {
      console.log(`未找到评论Id ${commentId}`);
      return null;
    }

    // 检查评论作者是否匹配
    if (article.commentList[commentIndex].authorEmail !== authorEmail) {
      console.log(
        `评论Id ${commentId} 的作者邮箱 ${article.commentList[commentIndex].authorEmail} 与提供的邮箱 ${authorEmail} 不匹配`
      );
      return null;
    }

    // 删除评论
    article.commentList.splice(commentIndex, 1);

    // 保存更新后的文章
    const updatedArticle = await article.save();

    // 返回更新之后的文章
    return updatedArticle;
  } catch (error) {
    console.log("Error deleting comment:", error);
    return null;
  }
};

// 删除文章评论的回复
// const deleteArticleCommentReply = async (articleId, commentId, replyId, authorEmail) => {
//   try {
//     // 使用模型
//     const Article = mongoose.model("Article", ArticleDetailSchema);

//     // 使用 updateOne 方法更新文章中的特定评论
//     const updatedArticle = await Article.updateOne(
//       { _id: articleId, "commentList._id": commentId }, // 查询条件
//       { $pull: { "commentList.$[comment].replyList": { _id: replyId } } }, // 更新操作
//       {
//         arrayFilters: [{ "comment._id": commentId }],
//         new: true, // 返回更新后的文档
//         runValidators: true, // 运行验证器
//       }
//     );

//     // 返回更新之后的文章
//     return updatedArticle;
//   } catch (error) {
//     console.log("Error deleting comment reply:", error);
//     return null;
//   }
// };
const deleteArticleCommentReply = async (
  articleId,
  commentId,
  replyId,
  authorEmail
) => {
  try {
    // 使用模型
    const Article = mongoose.model("Article", ArticleDetailSchema);

    // 查找文章
    const article = await Article.findById(articleId);

    if (!article) {
      console.log(`未找到文章Id ${articleId}`);
      return null;
    }

    // 查找评论
    const commentIndex = article.commentList.findIndex(
      (comment) => comment._id.toString() === commentId
    );

    if (commentIndex === -1) {
      console.log(`未找到评论Id ${commentId}`);
      return null;
    }

    // 查找回复
    const replyIndex = article.commentList[commentIndex].replyList.findIndex(
      (reply) => reply._id.toString() === replyId
    );

    if (replyIndex === -1) {
      console.log(`未找到回复Id ${replyId}`);
      return null;
    }

    // 检查回复作者是否匹配
    if (
      article.commentList[commentIndex].replyList[replyIndex].authorEmail !==
      authorEmail
    ) {
      console.log(
        `回复Id ${replyId} 的作者邮箱 ${article.commentList[commentIndex].replyList[replyIndex].authorEmail} 与提供的邮箱 ${authorEmail} 不匹配`
      );
      return null;
    }

    // 删除回复
    article.commentList[commentIndex].replyList.splice(replyIndex, 1);

    // 保存更新后的文章
    const updatedArticle = await article.save();

    // 返回更新之后的文章
    return updatedArticle;
  } catch (error) {
    console.log("评论回复删除失败：", error);
    return null;
  }
};

// 增加文章的点赞，点赞成功返回 true，否则返回 null
const addArticleLike = async (authorEmail, articleId) => {
  try {
    // 使用模型
    const Article = mongoose.model("Article", ArticleDetailSchema);

    // 获取点赞者信息
    const author = await getAuthorInfoById(authorEmail);

    // 未查询到点赞者时返回 null
    if (!author) {
      console.log(`未查询到作者 email ${authorEmail}`);
      return null;
    }

    // 未点赞过该文章时才增加点赞
    if (author.likesList.includes(articleId)) {
      console.log(`作者 ${authorEmail} 点赞文章过 ${articleId}`);
      return null;
    }

    // 增加作者点赞列表
    const res2 = await addLikeToAuthor(authorEmail, articleId);

    // 查询并且修改文章，增加点赞数
    const res = await Article.findByIdAndUpdate(
      articleId,
      { $inc: { likes: 1 } },
      { new: true } // 这个选项是为了返回更新后的文档
    );

    // 当文章和作者都存在时才返回 true
    if (!res && !res2) {
      console.log(
        `No article found with id ${articleId} or author ${authorEmail}`
      );
      return null;
    } else {
      // 点赞成功
      return true;
    }
  } catch (error) {
    console.error("Error adding article like:", error);
    return null;
  }
};

// 取消文章的点赞，取消点赞成功返回 true，否则返回 null
const cancelArticleLike = async (authorEmail, articleId) => {
  try {
    // 使用模型
    const Article = mongoose.model("Article", ArticleDetailSchema);

    // 查询点赞者信息
    const author = await getAuthorInfoById(authorEmail);

    // 未查询到点赞者时返回 null
    if (!author) {
      console.log(`未查询到作者 email ${authorEmail}`);
      return null;
    }

    // 未点赞过该文章时才取消点赞
    if (!author.likesList.includes(articleId)) {
      console.log(`作者 ${authorEmail} 未点赞文章 ${articleId}`);
      return null;
    }

    // 取消作者点赞列表
    const res2 = await deleteLikeFromAuthor(authorEmail, articleId);

    // 查询并且修改文章，减少点赞数
    const res = await Article.findByIdAndUpdate(
      articleId,
      { $inc: { likes: -1 } },
      { new: true } // 这个选项是为了返回更新后的文档
    );

    // 当文章和作者都存在时才返回 true
    if (!res && !res2) {
      console.log(`没有这篇文章 ${articleId} 没有找到作者 ${authorEmail}`);
      return null;
    } else {
      // 取消点赞成功
      return true;
    }
  } catch (error) {
    console.error("Error canceling article like:", error);
    return null;
  }
};

// 增加文章的浏览次数，成功返回更新后的文章，失败返回 null
const addArticleViewCount = async (articleId) => {
  try {
    // 使用模型
    const Article = mongoose.model("Article", ArticleDetailSchema);

    // 查询并且修改文章，增加浏览次数
    const res = await Article.findByIdAndUpdate(
      articleId,
      { $inc: { views: 1 } },
      { new: true } // 这个选项是为了返回更新后的文档
    );
    // 注意：这里不论是是否修改到文章，都返回更新后的文章
    // 只要文章查询到了就会返回文章，否则返回 null

    // 查询失败时返回 null
    if (!res) {
      console.log(`未找到文章Id ${articleId}`);
      return null;
    }

    // 返回更新后的文章
    return res;
  } catch (error) {
    console.error("Error adding article view count:", error);
    return null;
  }
};

// 增加文章的收藏数

// 减少文章的收藏数

// 发布文章
const publishArticle = async (authorId, articleId, articleInfo) => {
  try {
    // 判断作者是否存在
    const author = await getAuthorInfoById(authorId);

    //   未查询到作者时返回 null
    if (!author) {
      console.log(`未查询到作者 id ${authorId}`);
      return null;
    }

    // 判断文章
    if (author.articles.includes(articleId)) {
      // 说明作者需要更新文章
      const res = await modifyArticle(articleId, authorId, articleInfo);

      // 修改失败时返回 null
      if (!res) {
        console.log(`修改文章失败，articleId ${articleId}`);
        return null;
      }

      // 修改成功时返回修改后的文章
      return res;
    } else if (author.drafts.includes(articleId)) {
      // 说明作者需要将草稿发布为正式文章
      // 向作者的文章列表中添加文章
      const addArticleResult = await addArticle(authorId, articleInfo);

      // 增加文章失败时返回 null
      if (!addArticleResult) {
        console.log(`增加文章失败，articleId ${articleId}`);
        return null;
      }

      //
    }
  } catch (error) {
    console.error("Error publishing article:", error);
    return null;
  }
};

// 作者获取自己需要修改的文章，成功返回文章，失败返回 null
const getAuthorToModifyArticle = async (authorId, articleId) => {
  try {
    // 使用模型
    const Article = mongoose.model("Article", ArticleDetailSchema);

    // 查询作者
    const author = await isAuthorExist(authorId);

    // 未查询到作者时返回 null
    if (!author) {
      console.log(`未查询到作者 id ${authorId}`);
      return null;
    }

    // 查询文章是否存在
    const article = await Article.findById(articleId);

    // 未查询到文章时返回 null
    if (!article) {
      console.log(`未查询到文章 id ${articleId}`);
      return null;
    }

    // 作者是否拥有该文章
    if (!author.articles.includes(articleId)) {
      console.log(`作者 id ${authorId} 不拥有文章 id ${articleId}`);
      return null;
    }

    // 作者是否是文章的作者
    if (article.authorEmail !== authorId) {
      console.log(`文章 id ${articleId} 不是作者 id ${authorId} 的文章`);
      return null;
    }

    // 作者可以修改该文章
    return article;
  } catch (error) {
    console.error("Error getting author article:", error);
    return null;
  }
};

module.exports = {
  getAuthorToModifyArticle, // 作者获取自己需要修改的文章
  getPaginatedArticles, // 获取分页文章列表
  addArticle, // 增加文章
  modifyArticle, // 修改文章
  addComment, // 添加文章评论
  getArticleDetail, // 获取文章详情
  addArticleCommentReply, // 增加文章评论的回复
  deleteArticleCommentReply, // 删除文章评论的回复
  deleteArticleComment, // 删除文章评论
  addArticleLike, // 增加文章的点赞
  addArticleViewCount, // 增加文章的浏览次数
  deleteArticleById, // 删除文章通过文章的id
  cancelArticleLike, // 取消文章的点赞
};
